package se.study.io.byt;

import java.io.*;
import java.util.Arrays;

/**
 * @Author: tiger
 * @Date:2018/5/8
 * @Description:字节流处理
 */
public class ByteStudy {
    public static void main(String[] args) {
//        outputStream();
//        inputStream();
        fileCopy();
    }

    /**
     * 字节流文件复制
     * 执行部分错误写法：若文件字节总数不为1024整数倍，将导致最后一次读取时，字节数组补零情况，从而将补的零也被整体写出。
     * while (fis.read(bytes) != -1) {
     * fos.write(bytes);
     * }
     */
    private static void fileCopy() {
        try {
            // 字节流读取文件
            File source = new File("C:\\Tigerの工作\\交接文件-接入\\服务器.txt");
            FileInputStream fis = new FileInputStream(source);
            byte[] bytes = new byte[1024];
            // 字节流写出文件
            File target = new File("C:\\Users\\Administrator\\Desktop\\output_copy.txt");
            target.createNewFile();
            FileOutputStream fos = new FileOutputStream(target);
            // 执行
            // len:读取的字节数量，为-1则表示已经读取到文件末尾
            int len = -1;
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
            // 关闭资源
            fos.close();
            fis.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 注意：读取文件中的数据，读到最后没有数据时，返回-1
     * int read():读取一个字节，返回读取的字节
     * int read(byte[] b):读取多个字节,并保存到数组 b 中，从数组 b 的索引为 0 的位置开始存储，返回读取了几个字节
     * int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中，从数组b 的索引为 0 的位置开始，长度为len个字节
     */
    private static void inputStream() {
        File file = new File("C:\\Users\\Administrator\\Desktop\\output.txt");
        try {
            FileInputStream is = new FileInputStream(file);
            byte[] bytes = new byte[1000];
            int read = is.read(bytes);
            System.out.println("读取字节个数：" + read);
            System.out.println("读取字节数组：" + Arrays.toString(bytes));
            System.out.println("读取内容：" + new String(bytes));
            is.close();
            System.out.println("===========================");
            FileInputStream is2 = new FileInputStream(file);
            byte[] bytes2 = new byte[1000];
            // 读取len个字节保存到数组b中，off为保存到b中的起始偏移量
            int read2 = is2.read(bytes2, 4, 6);
            System.out.println("读取字节个数：" + read2);
            System.out.println("读取字节数组：" + Arrays.toString(bytes2));
            System.out.println("读取内容：" + new String(bytes2));
            is2.close();
        } catch (Exception e) {

        }
    }

    /**
     * void write(int b):把一个字节写入到文件中
     * void write(byte[] b):把数组b 中的所有字节写入到文件中
     * void write(byte[] b,int off,int len):把数组b 中的从 off 索引开始的 len 个字节写入到文件中
     */
    private static void outputStream() {
        File file = new File("C:\\Users\\Administrator\\Desktop\\output.txt");
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            FileOutputStream os = new FileOutputStream(file, true);
            byte[] bytes = "heiehi".getBytes("UTF-8");
            System.out.println("字节数组：" + Arrays.toString(bytes));
            // off:输出起始偏移量
            os.write(bytes, 2, 4);
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
